<template>
    <view class="container">
        <z-paging ref="paging" v-model="list" @query="queryList">
            <template #top>
                <!-- 自定义导航栏 -->
                <u-navbar :isBack="false" title="进货单" title-bold>
                    <template #right>
                        <view class="nav-right" @click="openDeleteMode">
                            <view v-if="!showDelete">管理</view>
                            <view v-else class="delete-cancel">
                                <text>管理</text>
                                <text class="icon" style="font-size: 24rpx">&#xe867;</text>
                            </view>
                        </view>
                    </template>
                </u-navbar>
                <!-- 商家名称 -->
                <view class="merchant-area" v-if="list.length > 0 || invalidList.length > 0">
                    <view class="u-flex u-col-center u-flex-1">
                        <view class="custom-check" @click="selectAll">
                            <text class="icon" :class="selectedAll ? 'icon-checked-cube' : 'icon-check-cube'"></text>
                        </view>
                        <view class="middle-content">
                            <u-image :src="merchant.logo" width="54" height="54" class="logo"></u-image>
                            <view class="merchant-name">{{ merchant.name }}</view>
                        </view>
                    </view>
                </view>
            </template>
            <view>
                <view class="content" v-for="good in list" :key="'good' + good.releaseId">
                    <view class="good-wrapper" v-for="(item, index) in Object.values(good.model)" :key="`__good__${index}`">
                        <cart-confirm-item
                            class="cart-confirm-item"
                            :item="item"
                            :good="good"
                            showCheck
                            @edit="editContent"
                            @check="onChangehandler"
                            @add="addThisSkuNum"
                            @modelCheck="modelCheck"
                            @showNumbox="showNumboxFn"
                            @change="countchange"
                            @deleteColor="deleteColor"
                            @deleteModel="deleteModel"
                        />
                    </view>
                </view>
                <!-- 8-14 新增 失效商品合集 -->
                <view class="expired-goods wrap" v-if="invalidList.length > 0">
                    <view class="title" style="letter-spacing: 3rpx">
                        <view>已失效商品{{ invalidList.length }}款</view>
                        <u-button size="mini" @click="clearInvalid" style="margin: 0">清空失效商品</u-button>
                    </view>
                    <view v-for="(invalid, idx) in invalidList" :key="`invalid-${invalid.releaseId}`" class="invalid-item">
                        <view class="u-flex">
                            <view style="position: relative">
                                <img-cache :src="`${global.productImageUrl}${invalid.skus[0].picId}/1`" width="150" height="150" border-radius="10" />
                                <view class="invalid-tag">已下架</view>
                            </view>
                            <view style="margin-left: 20rpx; line-height: 40rpx">
                                <view>{{ invalid.name }}</view>
                                <view>{{ invalid.count }}件</view>
                            </view>
                        </view>
                    </view>
                </view>
            </view>
            <template #bottom>
                <!-- 底部提交订单 栏 -->
                <view class="bottom-bar" v-if="list.length != 0 && !showDelete">
                    <view class="top">
                        <view class="u-flex u-row-between u-flex-1">
                            <view>
                                <text>共</text>
                                <text style="margin: 0 6rpx" class="u-main-color">{{ count }}</text>
                                <text>件商品</text>
                            </view>
                            <view>
                                <text>合计：</text>
                                <text class="price">￥{{ Number(sum).toFixed(2) }}</text>
                            </view>
                        </view>
                    </view>
                    <u-button :hair-line="false" class="btn-submit" type="p" :disabled="Object.keys(selectedSkus).length == 0" @click="submitOrder">提交订单</u-button>
                </view>
                <view v-if="showDelete" class="delete-options">
                    <u-button :hair-line="false" class="btn-submit" type="s" @click="deleteOrder(true)">删除并移入收藏</u-button>
                    <u-button :hair-line="false" class="btn-submit" type="p" @click="deleteOrder">删除</u-button>
                </view>
            </template>
        </z-paging>
    </view>
</template>

<script lang="ts" setup>
import { reactive, ref, getCurrentInstance, computed } from 'vue'
import { useGlobalStore, useUserStore } from '@/store'
import global from '@/config'

interface OBJ {
    [key: string]: any
}

const showDelete = ref(false)

const selectedAll = ref(false)
/** 待删除的对象 */
const deleteSkus = ref<OBJ>({})
/** 勾选单规格 */
const selectedSkus = ref<OBJ>({})
/** 商品 总价 */
const sum = ref(0)
/** 商品总数 */
const count = ref(0)
/** 购物单 列表 */
const list = ref<Array<any>>([])
/** 无效商品 */
const invalidList = ref<Array<any>>([])

const selectArr = ref<Array<any>>([])
/** 页面滚动时是否需要关闭 展开项 */
const needClose = ref(false)
/** 待关闭 numbox 的规格 */
const waitCloseSku = ref<Array<any>>([])

const instance = getCurrentInstance()

const remain = ref<OBJ>({})
/** 组件 z-paging 中的参数 */
const paging = ref<any>(null)

const merchant = reactive({
    logo: '/static/icon/10000.png',
    name: '超凡云仓服务中心'
})

const globalStore = useGlobalStore()
const userStore = useUserStore()

/** 是否为游客 */
const isVisitor = computed(() => {
    return userStore.userInfo.type == 3
})
/** 计算 滚动组件高度 屏幕高度 - 状态栏高度 - 导航栏高度 - 超凡云仓服务中心高度 - 提交订单的高度 - tabbar高度 - 底部安全区的高度*/
const scrollHeight = computed(() => {
    let { screenHeight, statusBarHeight, safeAreaInsets } = uni.getSystemInfoSync()
    let res = screenHeight - (statusBarHeight || 0) - 44 - 35 - 100 - 50 - (safeAreaInsets?.bottom || 0) + 'px'
    return res.toString()
})
/** 右上角 删除订单 点击之后可以勾选订单 进行删除 */
function openDeleteMode() {
    showDelete.value = !showDelete.value
    selectedAll.value = false
    if (!showDelete.value) {
        // 关闭 删除模式时  需要重置勾选项
        // 清除所有勾选项
        clearSelected()
        // 置空 待删除对象
        deleteSkus.value = {}
        updateInfo()
    } else {
        console.log('开启删除模式')
        clearSelected()
        // 置空 待删除对象
        deleteSkus.value = {}
        selectedSkus.value = {}
    }
}
/** 更新 商品总价 商品总数 */
function updateInfo() {
    let total = 0
    let s = 0
    Object.values(selectedSkus.value).map((m: any) => {
        s += Number(m.userPrice * m.num)
        total += m.num
    })
    sum.value = s
    count.value = total
}

/** 取消所有勾选项 */
function clearSelected() {
    list.value.forEach(item => {
        item.skus.forEach((sku: any) => {
            sku.check = false
        })
        Object.values(item.model).forEach((m: any) => {
            m.check = false
            Object.values(m.children).forEach((c: any) => {
                c.check = false
            })
        })
    })
    selectedSkus.value = {}
}
/** 全选订单 */
function selectAll() {
    selectedAll.value = !selectedAll.value
    // 如果是删除模式 允许全部选择
    if (showDelete.value) {
        console.log('删除模式下  允许全部选择')
        list.value.forEach(item => {
            // item.check = this.selectedAll
            // 改变 勾选框的变量
            Object.values(item.model).forEach((m: any) => {
                m.check = selectedAll.value
                Object.values(m.children).forEach((im: any) => {
                    im.check = selectedAll.value
                })
            })
            // 待删除数据 deleteSkus
            if (selectedAll.value) {
                item.skus.forEach((sku: any) => {
                    deleteSkus.value[sku.skuId] = sku
                })
            }
        })
        // 全不选的时候  需要置空  待删除项
        if (!selectedAll.value) deleteSkus.value = {}
    } else {
        // 不是删除模式 不允许选择 非法项
        console.log('非删除模式下  不允许选择非法项')
        // 全选时  忽略非法项
        if (selectedAll.value) {
            list.value.forEach(item => {
                // 改变 勾选框数据
                Object.values(item.model).forEach((m: any) => {
                    m.check = selectedAll.value
                    Object.values(m.children).forEach((im: any) => {
                        // 需要检查合法
                        if (im.list.some((n: any) => n.onSale == 1 && n.num <= n.stock && n.num > 0)) {
                            im.check = selectedAll.value
                        }
                    })
                })
                if (selectedAll.value) {
                    item.skus.forEach((sku: any) => {
                        if (sku.onSale == 1 && sku.num <= sku.stock && sku.num > 0) {
                            sku.check = true
                            selectedSkus.value[sku.skuId] = sku
                        }
                    })
                }
            })
            // 如果勾选之后 没有合法项  重置为空
            if (Object.keys(selectedSkus.value).length == 0) {
                uni.$u.toast('没有合法项!')
                selectedAll.value = false
            }
        } else {
            clearSelected()
        }
    }
    updateInfo()
}
/** 编辑规格 */
function editContent(item: any) {
    let res = list.value.filter(m => m.releaseId === item.releaseId)[0]

    globalStore.data = res
    let param = JSON.stringify({
        status: 4,
        match: true, // 需要匹配数量
        id: item.releaseId
    })
    uni.$u.$MRouter.skuCountEdit.to({ param })
}

function onChangehandler(sku: any) {
    // console.log(sku);
    // 1.删除模式下 可以选择无效项  showDelete:true  开启删除模式
    if (!showDelete.value) {
        // 首先判断当前项的尺码表中是否存在可以选择的尺码   有货  上架
        if (sku.list.some((m: any) => m.onSale == 1 && m.num <= m.stock && m.num > 0)) {
            sku.check = !sku.check
        } else {
            // 如果 此时为选中状态  尺码数量修改成了 非法状态  仍然需要可以取消勾选
            if (sku.check) {
                console.log('如果 此时为选中状态  尺码数量修改成了 非法状态  仍然需要可以取消勾选')
                sku.check = false
                sku.list.map((m: any) => {
                    m.check = false
                    delete selectedSkus.value[m.skuId]
                })
                return
            }
            console.log('非法')
            uni.$u.toast('尺码数量异常,该项不可选择!')
            return
        }
        // 若为真  添加 以SKUID 为名的属性
        if (sku.check) {
            sku.list.map((m: any) => {
                if (m.onSale == 1 && m.stock >= m.num && m.num > 0) {
                    m.check = true
                    selectedSkus.value[m.skuId] = m
                }
            })
        } else {
            sku.list.map((m: any) => {
                m.check = false
                delete selectedSkus.value[m.skuId]
            })
        }
        updateInfo()
        instance?.proxy?.$forceUpdate()
    } else {
        // 2. 删除模式下 可以选择无效项
        sku.check = !sku.check
        // 若为真  添加 以SKUID 为名的属性
        if (sku.check) {
            sku.list.map((m: any) => {
                deleteSkus.value[m.skuId] = m
            })
        } else {
            sku.list.map((m: any) => {
                // m.check = false
                delete deleteSkus.value[m.skuId]
            })
        }
    }
    // 变更状态之后 需要检验是否整个商品对象 的全选状态
    // 如果所有的规格 都为true 则表示 全选
    list.value.forEach(item => {
        Object.values(item.model).forEach((model: any) => {
            model.check = true
            // 是否存在 未勾选的颜色 对象 如果没有 则表示 该领型已经全选
            if (Object.values(model.children).some((colorObj: any) => !colorObj.check)) model.check = false
        })
    })
    // 预设 全选为true  再执行逻辑
    selectedAll.value = true
    if (list.value.some(m => Object.values(m.model).some((n: any) => !n.check))) selectedAll.value = false
}

/**
 * // 添加未加购的尺码
 * @param {Object} item
 * @param {Object} good
 * @param {Object} check 该项有没有被选中  如果被选中 则需要对selectskus 进行操作
 */
function addThisSkuNum(item: any, good: any, check: boolean) {
    if (item.stock <= 0) {
        uni.$u.toast('已售完!')
        return
    }
    if (item.onSale == 0) {
        uni.$u.toast('当前规格已经下架!')
        return
    }
    item.num = 1
    item.showNumbox = true
    needClose.value = true // 滚动时  需要关闭numbox
    waitCloseSku.value.push(item)
    console.log(waitCloseSku.value)
    // 调用接口 修改购物车 数量
    countchange(1, item, good)
    // 如果被勾选  则需要将item 添加进 selectskus
    if (check) {
        selectedSkus.value[item.skuId] = item
    }
}
/** number-box 组件 数量变化 */
function countchange(e: number, sku: any, good: any) {
    // 若修改的数量 超出库存 则自动修改为库存
    if (e > sku.stock) {
        uni.$u.toast('数量超过库存!')
    }
    // 数量减少到0 时  需要从 selectedSkus 中提出 该规格
    if (e == 0) {
        delete selectedSkus.value[sku.skuId]
    }
    uni.$u.debounce(() => {
        dealModelPriceNum(good.model)
        let sum = 0 // 数量
        let total = 0 // 金额
        good.skus.forEach((s: any) => {
            sum += Number(s.num)
            total += s.userPrice * s.num
        })
        good.count = sum
        good.sumPrice = total
        updateInfo()

        // 单个商品数量修改之后  需要修改购物车 整个的统计信息
        let arr = [
            {
                releaseSkuId: sku.releaseSkuId,
                releaseId: sku.releaseId,
                num: e
            }
        ]
        updateSkuDetail(arr)
    }, 500)
}

/**
 * 计算 领型对象的 小计 价格 数量
 * @param {Object} model
 */
function dealModelPriceNum(model: any) {
    Object.values(model).forEach((item: any) => {
        item.subCount = 0
        Object.values(item.children).forEach((color: any) => {
            color.list.forEach((n: any) => {
                if (n.onSale == 1 && n.num <= n.stock && n.num > 0) {
                    item.subCount += n.num
                    item.subPrice = Number(item.subCount * n.userPrice).toFixed(2)
                }
            })
        })
    })
}

/**
 * 修改购物车数量
 * @param {Numer} id 商品发布id
 * @param {Array} arr 商品sku 数组
 * @param {Boolean} update 是否需要刷新页面
 */
function updateSkuDetail(arr: Array<any>, update = false) {
    uni.$u.debounce(() => {
        uni.$u.$api.GoodsApi.updateBySkuIds(arr).then(() => {
            if (update) {
                /**TODO*/
                // this.mescroll.resetUpScroll();
                // this.mescroll.scrollTo(0)
                // this.$u.toast('购物车修改成功!');
            }
        })
    }, 200)
}

/**  勾选领型 */
function modelCheck(item: any) {
    // 删除模式下 可以选择非法 项
    if (showDelete.value) {
        // 1.改变 勾选框 状态
        item.check = !item.check
        // 2. 如果是选择  则将 sku 添加进 待删除数组中
        // 如果不是  则将待删除数组中的移除
        if (item.check) {
            Object.values(item.children).forEach((color: any) => {
                color.check = true
                color.list.forEach((sku: any) => {
                    deleteSkus.value[sku.skuId] = sku
                })
            })
        } else {
            Object.values(item.children).forEach((color: any) => {
                color.check = false
                color.list.forEach((sku: any) => {
                    delete deleteSkus.value[sku.skuId]
                })
            })
        }
    } else {
        // 非删除模式下  需要判断 所有子项  是否合法
        Object.values(item.children).forEach((colorObj: any) => {
            // 检查 是否存在 合法项
            if (colorObj.list.some((m: any) => m.onSale == 1 && m.num <= m.stock && m.num > 0)) {
                colorObj.check = !item.check
                colorObj.list.forEach((m: any) => {
                    if (m.onSale == 1 && m.num <= m.stock && m.num > 0) selectedSkus.value[m.skuId] = m
                })
            } else {
                uni.$u.toast('尺码数量异常,该项不可选择!')
            }
        })
        // 先预设为真
        item.check = true
        if (Object.values(item.children).some((m: any) => !m.check)) {
            item.check = false
            // 取消勾选的时候 需要把 this.selectedSkus 删除 相应项
            Object.values(item.children).forEach((colorObj: any) => {
                colorObj.list.forEach((m: any) => {
                    delete selectedSkus.value[m.skuId]
                })
            })
        }

        // 需要检查 是否 全选
        if (item.check) {
            // 先预设为真
            selectedAll.value = true
            if (list.value.some((m: any) => Object.values(m.model).some((n: any) => !n.check))) selectedAll.value = false
        } else {
            selectedAll.value = false
        }
    }
    updateInfo()
}
/** 显示 步进器组件 */
function showNumboxFn(sku: any) {
    if (sku.stock <= 0) {
        uni.$u.toast('已售完!')
        return
    }
    sku.showNumbox = true
    needClose.value = true // 滚动时  需要关闭numbox
    waitCloseSku.value.push(sku)
}

function deleteColor(arr: Array<any>) {
    updateSkuDetail(arr, true)
}

/**根据 releaseId  specificationsCollarId 删除购物车内容
 * @param {Object} e
 */
function deleteModel(e: any) {
    uni.$u.$api.GoodsApi.removeShoppingTrolleyByCollar({
        releaseId: e.releaseId,
        specificationsCollarId: e.specificationsCollarId
    }).then(() => {
        // this.mescroll.resetUpScroll();
        // TODO
    })
}
/** 删除无效商品 */
function clearInvalid() {
    let ids = invalidList.value.map(m => m.releaseId)
    removeCartItem(ids)
}
//删除购物车中的订单
function removeCartItem(list: Array<any>) {
    let ids = list
    uni.$u.$api.GoodsApi.delShoppingTrolleySkuDetail(ids).then(() => {
        // this.mescroll.resetUpScroll();
        // TODO
    })
}
// 提交订单
function submitOrder() {
    // 1. 判断是否有勾选商品
    if (Object.keys(selectedSkus.value).length === 0) {
        uni.$u.toast('请先选择要购买的商品!')
        return
    }
    if (!checkLimited()) {
        return
    }
    try {
        // 2. 判断勾选商品是否被下架
        checkGoodsStatus()
        // 3. 判断勾选商品是否0库存
        checkGoodsStock()
    } catch (err) {
        console.info(err)
        return
    }
    // 4. 判断用户权限
    globalStore.permissionCheck().then(() => {
        globalStore.remain = remain.value
        // getApp().globalData.remain = this.remain
        globalStore.data = uni.$u.deepClone(list.value)

        // 订单提交后是否需要删除购物车内的商品
        let para = JSON.stringify({
            clear: 1
        })
        uni.$u.$MRouter.confirmOrder.to({ from: 'cart', para })
    })
}

function deleteOrder(collection = false) {
    console.log(deleteSkus.value)
    if (Object.keys(deleteSkus.value).length > 0) {
        uni.$u.$showModal({
            content: '是否删除选定的规格?',
            success: (res: any) => {
                if (res.confirm) {
                    let ids: Array<any> = []
                    const releaseId = new Set()
                    Object.values(deleteSkus.value).map(m => {
                        if (m.id) {
                            ids.push(m.id)
                        }
                        releaseId.add(m.releaseId)
                    })
                    uni.$u.$api.GoodsApi.bathDelShoppingTrolleySkuDetail(ids).then(() => {
                        // 更新 selectedSkus
                        deleteSkus.value = {}
                        // this.mescroll.resetUpScroll()
                        // TODO
                        paging.value?.reload()
                        uni.$u.toast('删除成功!')
                    })
                    if (collection) {
                        handelFab([...releaseId])
                    }
                }
            }
        })
    } else {
        uni.$u.toast('请选择要删除的规格!')
    }
}

// 收藏
function handelFab(ids: Array<any>) {
    let para = {
        merchantId: userStore.userInfo.merchantId,
        goodsReleaseIds: ids,
        isCancel: 1
    }
    uni.$u.$api.GoodsApi.add2myFavorite(para)
        .then(() => {})
        .catch(() => {
            uni.$u.toast('收藏失败!')
        })
}

/** 检查商品上架状态 */
function checkGoodsStatus() {
    let arr = Object.values(selectedSkus.value)
    let online = arr.some(item => item.onSale === 0)
    if (online) {
        uni.$u.$showModal({
            title: '提示',
            content: '当前勾选的规格存在已下架规格!,是否清除失效的规格?',
            success: (res: any) => {
                if (res.confirm) {
                    let ids: Array<any> = []
                    arr.filter(m => m.onSale === 0).map(item => {
                        ids.push(item.id)
                    })
                    uni.$u.$api.GoodsApi.bathDelShoppingTrolleySkuDetail(ids).then(() => {
                        // this.mescroll.resetUpScroll()
                        // TODO
                        uni.$u.toast('删除成功!')
                        paging.value.reload()
                    })
                }
            }
        })
        throw new Error('商品已经下架!')
    }
}
/** 检查会员限购数量 */
function checkLimited() {
    // 判断是否数量 超出限制
    if (Object.keys(remain.value).length > 0) {
        for (let key in remain.value) {
            // console.log(key);
            let totalArr = []
            for (let item of Object.values(selectedSkus.value)) {
                // console.log(item);
                if (item.spuId == key) {
                    totalArr.push(item.num)
                }
            }
            let willBuy = totalArr.reduce((pre,current)=>{return pre + current})
            if (willBuy > remain.value[key].count) {
                uni.$u.toast('选购的商品数量超出限购,请修改数量!')
                return false
            }
        }
    }
    return true
}
/** 检查 商品库存信息 */
function checkGoodsStock() {
    let arr = Object.values(selectedSkus.value)
    if (arr.some(sku => sku.stock < sku.num)) {
        uni.$u.toast('当前存在库存不足商品！请确认!', 2000)
        throw new Error('库存不足!')
    }
}

/** 相当于 uni-mescroll 的 upCallback */
function queryList(pageNo: number, pageSize: number) {
    if (!userStore.token) {
        paging.value.complete(false)
        return
    }
    list.value = []
    invalidList.value = []
    uni.$u.$api.GoodsApi.queryShoppingTrolleySkuDetail({
        merchantId: userStore.userInfo.merchantId
    })
        .then((res: any) => {
            // 空的情况
            if (res.length === 0) return paging.value.complete(false)
            
            let spuIds = new Set()
            let temp: Array<any> = []
            let invalid: Array<any> = []
            res.forEach((good: any, index: number) => {
                delete good.update_time
                delete good.collarName
                // 以领型为单位 区分商品
                let model: any = {}
                let sum = 0
                good.skus.forEach((m: any) => {
                    spuIds.add(m.spuId)
                    delete m.updateTime
                    delete m.merchantId
                    delete m.collarSort
                    delete m.colorSort
                    delete m.samplePrice
                    delete m.sizeSort
                    let label = m.collarName
                    // 以领型建立对象
                    if (!model[label]) {
                        model[label] = {}
                        model[label].name = m.goodsName
                        model[label].collarName = m.collarName
                        model[label].collarText = m.modelTypeName
                        model[label].modelNo = m.modelNo
                        model[label].releaseId = m.releaseId
                        model[label].spuId = m.spuId
                        model[label].unid = uni.$u.guid(6)
                        // 领型唯一字段 用于删除
                        model[label].specificationsCollarId = m.specificationsCollarId
                        // 领型纬度的 商品金额小计  数量小计
                        model[label].subPrice = 0
                        model[label].subCount = 0
                        // 以颜色为分组 存入对象children
                        model[label].children = {}
                    }
                    let children = model[label].children

                    if (!children[m.colorName]) {
                        children[m.colorName] = {}
                        children[m.colorName].picId = m.picId
                        children[m.colorName].userPrice = m.userPrice
                        children[m.colorName].colorName = m.colorName
                        children[m.colorName].collarName = m.collarName
                        children[m.colorName].modelNo = m.modelNo
                        children[m.colorName].releaseId = m.releaseId
                        children[m.colorName].check = false
                        children[m.colorName].unid = uni.$u.guid(4)
                        children[m.colorName].list = []
                    }
                    children[m.colorName].list.push(m)

                    sum += m.num
                })
                dealModelPriceNum(model)
                // 计算 初始的
                good.count = sum
                good.model = model
            })
            // 由于 编辑规格 修改为0 时 需要传递num=0的数据  造成了 加购时会添加所有sku 包括颜色下 所有num都为0的情况
            // 因此 此处还需要将 res 中 未选择的 领型 及 颜色 对象 过滤
            res.forEach((releaseGood: any) => {
                releaseGood.skus = []
                Object.values(releaseGood.model).forEach((model: any) => {
                    // 如果某个颜色下 任意尺码的数量都为0  则删除这个颜色
                    for (const key in model.children) {
                        if (!model.children[key].list.some((m: any) => m.num > 0)) delete model.children[key]
                    }
                    // 删除未选择的颜色之后 如果整个model.children 为空对象 则删除 整个model
                    if (Object.keys(model.children).length === 0) delete releaseGood.model[model.collarName]
                })
                // 因为上一步 已经清空了 所有的skus  因此 还需要把剩下的 skus 存入 数组中
                Object.values(releaseGood.model).forEach((model: any) => {
                    Object.values(model.children).forEach((item: any) => {
                        item.list.forEach((sku: any) => {
                            releaseGood.skus.push(sku)
                        })
                    })
                })
            })
            // 需要判断 是否 某个商品 均没有 有效项
            res = res.filter((releaseGood: any) => Object.keys(releaseGood.model).length > 0)
            if (res.length === 0) {
                renderData([], [])
                return
            }
            // 会员限购查询
            if (userStore.userInfo.memberId) {
                // 查询 会员限购 情况
                uni.$u.$api.MemberApi.queryMemberRestriction({
                    memberId: userStore.userInfo.memberId,
                    spuIds: [...spuIds].join(',')
                })
                    .then((req: any) => {
                        req.map((m: any) => {
                            remain.value[m.spuId] = {}
                            remain.value[m.spuId].count = m.restrictionNum - m.purchasedNum
                        })

                        res.forEach((releaseGood: any) => {
                            Object.values(releaseGood.model).forEach((model: any) => {
                                model.remain = remain.value[model.spuId]?.count
                            })
                            // 无效商品判断
                            if (releaseGood.state != 0) {
                                invalid.push(releaseGood)
                            } else {
                                temp.push(releaseGood)
                            }
                        })
                    })
                    .finally(() => {
                        renderData(temp, invalid)
                    })
            } else {
                res.forEach((releaseGood: any) => {
                    // 无效商品判断
                    if (releaseGood.state != 0) {
                        invalid.push(releaseGood)
                    } else {
                        temp.push(releaseGood)
                    }
                })
                renderData(temp, invalid)
            }
        })
        .catch(() => {
            paging.value.complete(false)
        })
}

function renderData(temp: Array<any>, invalid: Array<any>) {
    list.value = temp
    invalidList.value = invalid
    selectedAll.value = false
    selectArr.value = []
    selectedSkus.value = {}
    sum.value = 0
    count.value = 0
    // TODO
    // this.mescroll.lockUpScroll(true); // 锁定上拉加载
    // 当购物车 有效商品数量空  但是 有失效商品的时候  需要
    if (list.value.length == 0) {
        paging.value.complete(invalidList.value)
    } else {
        paging.value.complete(list.value)
    }
}
</script>

<style scoped lang="scss">
@import './index.scss';
</style>
